home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / language / pcl_src.zoo / march-92-notes.txt < prev    next >
Text File  |  1992-04-19  |  14KB  |  312 lines
  1. These notes correspond to the "March 92 PCL (beta1)" version of PCL.
  2.  
  3.   This version of PCL is much closer than previous versions of PCL
  4. to the metaobject protocol specified in "The Art of the Metaobject Protocol", 
  5. chapters 5 and 6, by Gregor Kiczales, Jim des Riveres, and Daniel G. Bobrow.
  6.  
  7.  
  8. [Please read the file may-day-notes.text also.  Most of that file still applies.]
  9.  
  10. Support for structures
  11.   You can use structure-class as a metaclass to create new classes.
  12.   Classes created this way create and evaluate defstruct forms which
  13.   have generated symbols for the structure accessors and constructor.
  14.   The generated symbols are used by the primary slot-value-using-class
  15.   methods and by the primary allocate-instance method for structures.
  16.   Defmethod optimizes usages of slot-value (when no user-defined 
  17.   slot-value-using-class methods exist) into direct calls of the
  18.   generated symbol accessor, which the compiler can then optimize further.
  19.   Even when there are user-defined methods on slot-value-using-class,
  20.   PCL does a variety of optimizations.
  21.   
  22.   If your implementation's version of the *-low.lisp file
  23.   contains definitions of certain structure functions (see the end of
  24.   low.lisp, cmu-low.lisp, lucid-low.lisp, and kcl-low.lisp), then
  25.   structure classes are supported for all defstructs.  In this case,
  26.   structure classes are created automatically, when necessary.
  27.  
  28. New Classes:
  29. structure-class
  30. structure-object
  31. slot-class
  32. slot-object
  33. structure-direct-slot-definition
  34. structure-effective-slot-definition
  35.  
  36. Improvements to slot-access
  37.   Optimization for slot-value outsize of defmethod
  38.   Optimization for slot-value inside of defmethod, but not of a specialized parameter.
  39.   Optimizations that work even when there are :around methods
  40.   on slot-value-using-class.
  41.  
  42. New types: 
  43.    `(class ,class-object)
  44.    `(class-eq ,class-object)
  45.  
  46. New specializer class: class-eq-specializer
  47.   Every class has a class-eq specializer which represents all
  48.   the direct instances of that class.
  49.   This is useful in *subtypep.  For example, here is the way 
  50.   generic-function initialization checks that the method-class is valid:
  51.    (and (classp method-class)
  52.     (*subtypep (class-eq-specializer method-class)
  53.            (find-class 'standard-method)))
  54.   If you want to define methods having class-eq specializers,
  55.   see "Initialization of method metaobjects".  The default behavior of PCL
  56.   is to disallow this.
  57.  
  58. compute-applicable-methods-using-types
  59.  
  60. caching improvements
  61.  
  62. no magic-generic-functions list
  63.   This simplifies some things, but complicates some other things.
  64.   I wanted to support user-defined classes which are their own metaclass.
  65.   You can now do:
  66. (defclass y (standard-class) ())
  67. (defmethod validate-superclass ((c y) (sc standard-class)) t)
  68. (defclass y (standard-class) () (:metaclass y))
  69.  
  70. method-function changes (see the comments for make-method-lambda, below)
  71.  
  72. final dfuns
  73.  
  74. -------------------------
  75.  
  76. gfs which obey AMOP ch 6
  77.   add-dependent
  78.   add-direct-method
  79.   add-direct-subclass
  80.   add-method
  81.   allocate-instance
  82.   compute-class-precedence-list
  83.   compute-default-initargs
  84.   compute-effective-slot-definition
  85. [Note: compute-effective-slot-definition relys on 
  86.  compute-effective-slot-definition-initargs and effective-slot-definition-class.
  87.  compute-effective-slot-definition-initargs is quite useful, but is not in
  88.  AMOP ch 6.]
  89.   compute-slots
  90.   direct-slot-definition-class
  91.   effective-slot-definition-class
  92.   ensure-class
  93.   ensure-class-using-class
  94.   ensure-generic-function
  95.   ensure-generic-function-using-class
  96.   eql-specializer-object
  97.   extract-lambda-list
  98.   extract-specializer-names
  99.   finalize-inheritance
  100.   find-method-combination
  101.   funcallable-standard-instance-access
  102.   {generic-function-method-class, generic-function-method-combination,
  103.    generic-function-lambda-list, generic-function-methods, generic-function-name}
  104.   intern-eql-specializer
  105.   make-instance
  106.   map-dependents
  107.   {method-function, method-generic-function, method-lambda-list,
  108.    method-specializers, method-qualifiers}
  109.   {class-default-initargs, class-direct-default-initargs, class-direct-slots,
  110.    class-direct-subclasses, class-direct-superclasses, class-finalized-p,
  111.    class-name, class-precedence-list, class-prototype, class-slots}
  112.   {slot-definition-allocation, slot-definition-initargs, slot-definition-initform,
  113.    slot-definition-initfunction, slot-definition-name, slot-definition-type}
  114.   {slot-definition-readers, slot-definition-writers}
  115.   {slot-definition-location}
  116.   remove-dependent
  117.   remove-direct-method
  118.   remove-direct-subclass
  119.   remove-method
  120.   set-funcallable-instance-function
  121.   (setf slot-value-using-class)
  122.   slot-boundp-using-class
  123.   slot-makunbound-using-class
  124.   specializer-direct-generic-functions
  125.   specializer-direct-methods
  126.   standard-instance-access
  127.   update-dependent
  128.  
  129. gfs which DO NOT obey AMOP ch 6
  130.  
  131. accessor-method-slot-definition
  132.   Not yet defined.  Use accessor-method-slot-name and method-specializers
  133.   to get the direct-slot-definition.
  134.  
  135. compute-applicable-methods
  136. compute-applicable-methods-using-classes
  137.   Handles class-eq specializers without signalling an error.  
  138.   But see "Initialization of method metaobjects", below.
  139.  
  140. compute-discriminating-function
  141.   [the resulting function works differently different because 
  142.    compute-effective-method is different, and because make-method-lambda 
  143.    does not exist.]
  144.  
  145. compute-effective-method
  146.   Returns only one value.  The utility of bringing this into conformance with
  147.   AMOP ch 6 is limited by the lack of make-method-lambda.
  148.  
  149. generic-function-argument-precedence-order
  150.   Not yet defined.  Can get this information from the arg-info structure.
  151.  
  152. generic-function-declarations
  153.   Not yet defined.
  154.  
  155. make-method-lambda
  156.   Does not exist.  This will be hard to add in a way that is compatible with
  157.   AMOP ch 6.
  158.   1. In March 92 PCL, there are two kinds of method-functions.  The first kind
  159.      is what method-function returns (which has no special restrinctions on its use).
  160.      The second kind is returned by method-function-for-caching, which is used
  161.      when the wrappers of the required arguments are known.  Each call to
  162.      method-function-for-caching might return a new function.  Both kinds of
  163.      method functions can be closures.  March 92 PCL currently uses this scheme
  164.      to do the pv-lookup ahead of time, thereby eliminating pv caching.
  165.      (pv-lookup means the lookup of the permutation vectors which are used for
  166.      fast instance varaible access.)   Method function closures can also be used
  167.      in the optimization of calls to generic-functions, but this has not yet been
  168.      implemented.
  169.   2. Since method-functions can be closures, we would need an extra step between
  170.      compiling (or coercing) the method-lambda into a function, before it can be 
  171.      applied to arguments with apply or funcall.     
  172.  
  173. reader-method-class
  174.   Not yet defined.  Some bootstrapping considerations are involved, 
  175.   but adding this will not be very hard.
  176.  
  177. (setf class-name)
  178.   Currently just a writer method.  Does not call reinitialize-instance or
  179.   (setf find-class).
  180.  
  181. (setf generic-function-name)
  182.   Currently just a writer method.  Does not call reinitialize-instance.
  183.  
  184. writer-method-class
  185.   Not yet defined.  Some bootstrapping considerations are involved, 
  186.   but adding this will not be very hard.
  187.  
  188. ---------------------------
  189.  
  190. Initialization of method metaobjects
  191.   The following methods are defined:
  192.     legal-qualifiers-p (method standard-method) qualifiers
  193.     legal-lambda-list-p (method standard-method) lambda-list
  194.     legal-specializers-p (method standard-method) specializers
  195.     legal-method-function-p (method standard-method) function
  196.     legal-documentation-p (method standard-method) documentation
  197.  
  198.     legal-specializer-p (method standard-method) specializer
  199.  
  200.   You can override them if you want.
  201.   The method for legal-specializers-p calls legal-specializer-p
  202.   on each specializer.
  203.   The method for legal-specializer-p allows any kind of specializer
  204.   when the vari